Developer CD Series 1999 July: Mac OS SDK/Dev.CD Jul 99 SDK1.toast/Development Kits/Mac OS/Interfaces&Libraries/Universal/Interfaces/AIncludes/LowMem.a

Text File | 1998-08-17 | 108.5 KB | 4,846 lines | [TEXT/MPS ]

;
;    File:        LowMem.a
;
;    Contains:    Low Memory Accessor Interfaces.
;
;    Version:    Technology:    Mac OS 8.1
;                Release:    Universal Interfaces 3.2
;
;    Copyright:    © 1993-1998 by Apple Computer, Inc., all rights reserved
;
;    Bugs?:        For bug reports, consult the following page on
;                the World Wide Web:
;
;                    http://developer.apple.com/bugreporter/
;
;
    IF &TYPE('__LOWMEM__') = 'UNDEFINED' THEN
__LOWMEM__ SET 1

    IF &TYPE('__MACTYPES__') = 'UNDEFINED' THEN
    include 'MacTypes.a'
    ENDIF
    IF &TYPE('__CONTROLS__') = 'UNDEFINED' THEN
    include 'Controls.a'
    ENDIF
    IF &TYPE('__EVENTS__') = 'UNDEFINED' THEN
    include 'Events.a'
    ENDIF
    IF &TYPE('__FILES__') = 'UNDEFINED' THEN
    include 'Files.a'
    ENDIF
    IF &TYPE('__FONTS__') = 'UNDEFINED' THEN
    include 'Fonts.a'
    ENDIF
    IF &TYPE('__MACMEMORY__') = 'UNDEFINED' THEN
    include 'MacMemory.a'
    ENDIF
    IF &TYPE('__MENUS__') = 'UNDEFINED' THEN
    include 'Menus.a'
    ENDIF
    IF &TYPE('__OSUTILS__') = 'UNDEFINED' THEN
    include 'OSUtils.a'
    ENDIF
    IF &TYPE('__QUICKDRAW__') = 'UNDEFINED' THEN
    include 'Quickdraw.a'
    ENDIF
    IF &TYPE('__RESOURCES__') = 'UNDEFINED' THEN
    include 'Resources.a'
    ENDIF

    IF &TYPE('__MACWINDOWS__') = 'UNDEFINED' THEN
    include 'MacWindows.a'
    ENDIF
; **************************************************************************************
;
;    SIMPLE LOWMEM ACCESSORS
;
;*************************************************************************************

;
; pascal SInt16 LMGetScrVRes(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetScrVRes         &dest=(sp)
            move.w            $0102,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetScrVRes
    ENDIF

;
; pascal void LMSetScrVRes(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetScrVRes         &src=(sp)+
            move.w            &src,$0102
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetScrVRes
    ENDIF


;
; pascal SInt16 LMGetScrHRes(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetScrHRes         &dest=(sp)
            move.w            $0104,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetScrHRes
    ENDIF

;
; pascal void LMSetScrHRes(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetScrHRes         &src=(sp)+
            move.w            &src,$0104
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetScrHRes
    ENDIF


;
; pascal Ptr LMGetMemTop(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetMemTop          &dest=(sp)
            move.l            $0108,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetMemTop
    ENDIF

;
; pascal void LMSetMemTop(Ptr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetMemTop          &src=(sp)+
            move.l            &src,$0108
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetMemTop
    ENDIF


;
; pascal Ptr LMGetBufPtr(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetBufPtr          &dest=(sp)
            move.l            $010C,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetBufPtr
    ENDIF

;
; pascal void LMSetBufPtr(Ptr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetBufPtr          &src=(sp)+
            move.l            &src,$010C
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetBufPtr
    ENDIF


;
; pascal Ptr LMGetHeapEnd(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetHeapEnd         &dest=(sp)
            move.l            $0114,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetHeapEnd
    ENDIF

;
; pascal void LMSetHeapEnd(Ptr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetHeapEnd         &src=(sp)+
            move.l            &src,$0114
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetHeapEnd
    ENDIF


;
; pascal THz LMGetTheZone(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetTheZone         &dest=(sp)
            move.l            $0118,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetTheZone
    ENDIF

;
; pascal void LMSetTheZone(THz value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetTheZone         &src=(sp)+
            move.l            &src,$0118
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetTheZone
    ENDIF


;
; pascal Ptr LMGetUTableBase(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetUTableBase      &dest=(sp)
            move.l            $011C,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetUTableBase
    ENDIF

;
; pascal void LMSetUTableBase(Ptr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetUTableBase      &src=(sp)+
            move.l            &src,$011C
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetUTableBase
    ENDIF


;
; pascal UInt8 LMGetCPUFlag(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetCPUFlag         &dest=(sp)
            move.b            $012F,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetCPUFlag
    ENDIF

;
; pascal void LMSetCPUFlag(UInt8 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetCPUFlag         &src=(sp)+
            move.b            &src,$012F
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetCPUFlag
    ENDIF


;
; pascal Ptr LMGetApplLimit(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetApplLimit       &dest=(sp)
            move.l            $0130,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetApplLimit
    ENDIF

;
; pascal void LMSetApplLimit(Ptr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetApplLimit       &src=(sp)+
            move.l            &src,$0130
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetApplLimit
    ENDIF


;
; pascal SInt16 LMGetSysEvtMask(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSysEvtMask      &dest=(sp)
            move.w            $0144,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSysEvtMask
    ENDIF

;
; pascal void LMSetSysEvtMask(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSysEvtMask      &src=(sp)+
            move.w            &src,$0144
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSysEvtMask
    ENDIF


;
; pascal SInt32 LMGetRndSeed(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetRndSeed         &dest=(sp)
            move.l            $0156,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetRndSeed
    ENDIF

;
; pascal void LMSetRndSeed(SInt32 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetRndSeed         &src=(sp)+
            move.l            &src,$0156
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetRndSeed
    ENDIF


;
; pascal UInt8 LMGetSEvtEnb(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSEvtEnb         &dest=(sp)
            move.b            $015C,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSEvtEnb
    ENDIF

;
; pascal void LMSetSEvtEnb(UInt8 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSEvtEnb         &src=(sp)+
            move.b            &src,$015C
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSEvtEnb
    ENDIF


;
; pascal UInt32 LMGetTicks(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetTicks           &dest=(sp)
            move.l            $016A,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetTicks
    ENDIF

;
; pascal void LMSetTicks(UInt32 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetTicks           &src=(sp)+
            move.l            &src,$016A
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetTicks
    ENDIF


;
; pascal SInt16 LMGetKeyThresh(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetKeyThresh       &dest=(sp)
            move.w            $018E,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetKeyThresh
    ENDIF

;
; pascal void LMSetKeyThresh(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetKeyThresh       &src=(sp)+
            move.w            &src,$018E
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetKeyThresh
    ENDIF


;
; pascal SInt16 LMGetKeyRepThresh(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetKeyRepThresh    &dest=(sp)
            move.w            $0190,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetKeyRepThresh
    ENDIF

;
; pascal void LMSetKeyRepThresh(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetKeyRepThresh    &src=(sp)+
            move.w            &src,$0190
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetKeyRepThresh
    ENDIF


;
; pascal Ptr LMGetVIA(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetVIA             &dest=(sp)
            move.l            $01D4,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetVIA
    ENDIF

;
; pascal void LMSetVIA(Ptr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetVIA             &src=(sp)+
            move.l            &src,$01D4
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetVIA
    ENDIF


;
; pascal Ptr LMGetSCCRd(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSCCRd           &dest=(sp)
            move.l            $01D8,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSCCRd
    ENDIF

;
; pascal void LMSetSCCRd(Ptr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSCCRd           &src=(sp)+
            move.l            &src,$01D8
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSCCRd
    ENDIF


;
; pascal Ptr LMGetSCCWr(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSCCWr           &dest=(sp)
            move.l            $01DC,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSCCWr
    ENDIF

;
; pascal void LMSetSCCWr(Ptr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSCCWr           &src=(sp)+
            move.l            &src,$01DC
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSCCWr
    ENDIF


;
; pascal UInt8 LMGetSPValid(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSPValid         &dest=(sp)
            move.b            $01F8,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSPValid
    ENDIF

;
; pascal void LMSetSPValid(UInt8 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSPValid         &src=(sp)+
            move.b            &src,$01F8
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSPValid
    ENDIF


;
; pascal UInt8 LMGetSPATalkA(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSPATalkA        &dest=(sp)
            move.b            $01F9,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSPATalkA
    ENDIF

;
; pascal void LMSetSPATalkA(UInt8 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSPATalkA        &src=(sp)+
            move.b            &src,$01F9
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSPATalkA
    ENDIF


;
; pascal UInt8 LMGetSPATalkB(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSPATalkB        &dest=(sp)
            move.b            $01FA,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSPATalkB
    ENDIF

;
; pascal void LMSetSPATalkB(UInt8 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSPATalkB        &src=(sp)+
            move.b            &src,$01FA
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSPATalkB
    ENDIF


;
; pascal UInt8 LMGetSPConfig(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSPConfig        &dest=(sp)
            move.b            $01FB,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSPConfig
    ENDIF

;
; pascal void LMSetSPConfig(UInt8 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSPConfig        &src=(sp)+
            move.b            &src,$01FB
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSPConfig
    ENDIF


;
; pascal SInt16 LMGetSPPortA(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSPPortA         &dest=(sp)
            move.w            $01FC,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSPPortA
    ENDIF

;
; pascal void LMSetSPPortA(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSPPortA         &src=(sp)+
            move.w            &src,$01FC
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSPPortA
    ENDIF


;
; pascal SInt16 LMGetSPPortB(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSPPortB         &dest=(sp)
            move.w            $01FE,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSPPortB
    ENDIF

;
; pascal void LMSetSPPortB(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSPPortB         &src=(sp)+
            move.w            &src,$01FE
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSPPortB
    ENDIF


;
; pascal SInt32 LMGetSPAlarm(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSPAlarm         &dest=(sp)
            move.l            $0200,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSPAlarm
    ENDIF

;
; pascal void LMSetSPAlarm(SInt32 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSPAlarm         &src=(sp)+
            move.l            &src,$0200
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSPAlarm
    ENDIF


;
; pascal SInt16 LMGetSPFont(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSPFont          &dest=(sp)
            move.w            $0204,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSPFont
    ENDIF

;
; pascal void LMSetSPFont(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSPFont          &src=(sp)+
            move.w            &src,$0204
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSPFont
    ENDIF


;
; pascal UInt8 LMGetSPKbd(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSPKbd           &dest=(sp)
            move.b            $0206,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSPKbd
    ENDIF

;
; pascal void LMSetSPKbd(UInt8 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSPKbd           &src=(sp)+
            move.b            &src,$0206
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSPKbd
    ENDIF


;
; pascal UInt8 LMGetSPPrint(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSPPrint         &dest=(sp)
            move.b            $0207,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSPPrint
    ENDIF

;
; pascal void LMSetSPPrint(UInt8 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSPPrint         &src=(sp)+
            move.b            &src,$0207
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSPPrint
    ENDIF


;
; pascal UInt8 LMGetSPVolCtl(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSPVolCtl        &dest=(sp)
            move.b            $0208,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSPVolCtl
    ENDIF

;
; pascal void LMSetSPVolCtl(UInt8 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSPVolCtl        &src=(sp)+
            move.b            &src,$0208
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSPVolCtl
    ENDIF


;
; pascal UInt8 LMGetSPClikCaret(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSPClikCaret     &dest=(sp)
            move.b            $0209,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSPClikCaret
    ENDIF

;
; pascal void LMSetSPClikCaret(UInt8 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSPClikCaret     &src=(sp)+
            move.b            &src,$0209
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSPClikCaret
    ENDIF


;
; pascal UInt8 LMGetSPMisc2(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSPMisc2         &dest=(sp)
            move.b            $020B,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSPMisc2
    ENDIF

;
; pascal void LMSetSPMisc2(UInt8 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSPMisc2         &src=(sp)+
            move.b            &src,$020B
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSPMisc2
    ENDIF


;
; pascal SInt32 LMGetTime(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetTime            &dest=(sp)
            move.l            $020C,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetTime
    ENDIF

;
; pascal void LMSetTime(SInt32 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetTime            &src=(sp)+
            move.l            &src,$020C
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetTime
    ENDIF


;
; pascal SInt16 LMGetBootDrive(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetBootDrive       &dest=(sp)
            move.w            $0210,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetBootDrive
    ENDIF

;
; pascal void LMSetBootDrive(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetBootDrive       &src=(sp)+
            move.w            &src,$0210
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetBootDrive
    ENDIF


;
; pascal SInt16 LMGetSFSaveDisk(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSFSaveDisk      &dest=(sp)
            move.w            $0214,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSFSaveDisk
    ENDIF

;
; pascal void LMSetSFSaveDisk(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSFSaveDisk      &src=(sp)+
            move.w            &src,$0214
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSFSaveDisk
    ENDIF


;
; pascal UInt8 LMGetKbdLast(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetKbdLast         &dest=(sp)
            move.b            $0218,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetKbdLast
    ENDIF

;
; pascal void LMSetKbdLast(UInt8 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetKbdLast         &src=(sp)+
            move.b            &src,$0218
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetKbdLast
    ENDIF


;
; pascal UInt8 LMGetKbdType(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetKbdType         &dest=(sp)
            move.b            $021E,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetKbdType
    ENDIF

;
; pascal void LMSetKbdType(UInt8 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetKbdType         &src=(sp)+
            move.b            &src,$021E
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetKbdType
    ENDIF


;
; pascal SInt16 LMGetMemErr(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetMemErr          &dest=(sp)
            move.w            $0220,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetMemErr
    ENDIF

;
; pascal void LMSetMemErr(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetMemErr          &src=(sp)+
            move.w            &src,$0220
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetMemErr
    ENDIF


;
; pascal UInt8 LMGetSdVolume(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSdVolume        &dest=(sp)
            move.b            $0260,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSdVolume
    ENDIF

;
; pascal void LMSetSdVolume(UInt8 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSdVolume        &src=(sp)+
            move.b            &src,$0260
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSdVolume
    ENDIF


;
; pascal Ptr LMGetSoundPtr(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSoundPtr        &dest=(sp)
            move.l            $0262,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSoundPtr
    ENDIF

;
; pascal void LMSetSoundPtr(Ptr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSoundPtr        &src=(sp)+
            move.l            &src,$0262
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSoundPtr
    ENDIF


;
; pascal Ptr LMGetSoundBase(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSoundBase       &dest=(sp)
            move.l            $0266,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSoundBase
    ENDIF

;
; pascal void LMSetSoundBase(Ptr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSoundBase       &src=(sp)+
            move.l            &src,$0266
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSoundBase
    ENDIF


;
; pascal UInt8 LMGetSoundLevel(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSoundLevel      &dest=(sp)
            move.b            $027F,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSoundLevel
    ENDIF

;
; pascal void LMSetSoundLevel(UInt8 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSoundLevel      &src=(sp)+
            move.b            &src,$027F
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSoundLevel
    ENDIF


;
; pascal SInt16 LMGetCurPitch(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetCurPitch        &dest=(sp)
            move.w            $0280,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetCurPitch
    ENDIF

;
; pascal void LMSetCurPitch(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetCurPitch        &src=(sp)+
            move.w            &src,$0280
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetCurPitch
    ENDIF


;
; pascal SInt16 LMGetROM85(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetROM85           &dest=(sp)
            move.w            $028E,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetROM85
    ENDIF

;
; pascal void LMSetROM85(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetROM85           &src=(sp)+
            move.w            &src,$028E
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetROM85
    ENDIF


;
; pascal UInt8 LMGetPortBUse(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetPortBUse        &dest=(sp)
            move.b            $0291,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetPortBUse
    ENDIF

;
; pascal void LMSetPortBUse(UInt8 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetPortBUse        &src=(sp)+
            move.b            &src,$0291
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetPortBUse
    ENDIF


;
; pascal GetNextEventFilterUPP LMGetGNEFilter(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetGNEFilter       &dest=(sp)
            move.l            $029A,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetGNEFilter
    ENDIF

;
; pascal void LMSetGNEFilter(GetNextEventFilterUPP value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetGNEFilter       &src=(sp)+
            move.l            &src,$029A
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetGNEFilter
    ENDIF


;
; pascal THz LMGetSysZone(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSysZone         &dest=(sp)
            move.l            $02A6,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSysZone
    ENDIF

;
; pascal void LMSetSysZone(THz value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSysZone         &src=(sp)+
            move.l            &src,$02A6
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSysZone
    ENDIF


;
; pascal THz LMGetApplZone(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetApplZone        &dest=(sp)
            move.l            $02AA,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetApplZone
    ENDIF

;
; pascal void LMSetApplZone(THz value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetApplZone        &src=(sp)+
            move.l            &src,$02AA
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetApplZone
    ENDIF


;
; pascal Ptr LMGetROMBase(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetROMBase         &dest=(sp)
            move.l            $02AE,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetROMBase
    ENDIF

;
; pascal void LMSetROMBase(Ptr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetROMBase         &src=(sp)+
            move.l            &src,$02AE
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetROMBase
    ENDIF


;
; pascal Ptr LMGetRAMBase(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetRAMBase         &dest=(sp)
            move.l            $02B2,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetRAMBase
    ENDIF

;
; pascal void LMSetRAMBase(Ptr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetRAMBase         &src=(sp)+
            move.l            &src,$02B2
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetRAMBase
    ENDIF


;
; pascal Ptr LMGetDSAlertTab(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetDSAlertTab      &dest=(sp)
            move.l            $02BA,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetDSAlertTab
    ENDIF

;
; pascal void LMSetDSAlertTab(Ptr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetDSAlertTab      &src=(sp)+
            move.l            &src,$02BA
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetDSAlertTab
    ENDIF



;
;    NOTE:    LMGetABusVars and LMSetABusVars have been removed.
;            Their implememtation in InterfaceLib was inconsistent
;            with their prototypes here.  In InterfaceLib LMSetABusVars
;            would copy eight bytes and LMGetABusVars would return the
;            value 0x02D8 instead of the long at that location.
;
;            Use LMGetABusGlobals/LMSetABusGlobals to get/set the
;            long at location 0x02D8 which is a pointer to the AppleTalk
;            globals.  Use LMGetABusDCE/LMSetABusDCE to get/set the
;            long at location 0x02DC which is the .MPP driver
;            Device Control Entry.
;
;

;
; pascal Ptr LMGetABusGlobals(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetABusGlobals     &dest=(sp)
            move.l            $02D8,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetABusGlobals
    ENDIF

;
; pascal void LMSetABusGlobals(Ptr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetABusGlobals     &src=(sp)+
            move.l            &src,$02D8
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetABusGlobals
    ENDIF

;
; pascal Ptr LMGetABusDCE(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetABusDCE         &dest=(sp)
            move.l            $02DC,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetABusDCE
    ENDIF

;
; pascal void LMSetABusDCE(Ptr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetABusDCE         &src=(sp)+
            move.l            &src,$02DC
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetABusDCE
    ENDIF



;
; pascal UInt32 LMGetDoubleTime(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetDoubleTime      &dest=(sp)
            move.l            $02F0,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetDoubleTime
    ENDIF

;
; pascal void LMSetDoubleTime(UInt32 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetDoubleTime      &src=(sp)+
            move.l            &src,$02F0
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetDoubleTime
    ENDIF


;
; pascal UInt32 LMGetCaretTime(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetCaretTime       &dest=(sp)
            move.l            $02F4,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetCaretTime
    ENDIF

;
; pascal void LMSetCaretTime(UInt32 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetCaretTime       &src=(sp)+
            move.l            &src,$02F4
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetCaretTime
    ENDIF


;
; pascal UInt8 LMGetScrDmpEnb(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetScrDmpEnb       &dest=(sp)
            move.b            $02F8,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetScrDmpEnb
    ENDIF

;
; pascal void LMSetScrDmpEnb(UInt8 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetScrDmpEnb       &src=(sp)+
            move.b            &src,$02F8
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetScrDmpEnb
    ENDIF


;
; pascal SInt32 LMGetBufTgFNum(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetBufTgFNum       &dest=(sp)
            move.l            $02FC,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetBufTgFNum
    ENDIF

;
; pascal void LMSetBufTgFNum(SInt32 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetBufTgFNum       &src=(sp)+
            move.l            &src,$02FC
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetBufTgFNum
    ENDIF


;
; pascal SInt16 LMGetBufTgFFlg(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetBufTgFFlg       &dest=(sp)
            move.w            $0300,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetBufTgFFlg
    ENDIF

;
; pascal void LMSetBufTgFFlg(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetBufTgFFlg       &src=(sp)+
            move.w            &src,$0300
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetBufTgFFlg
    ENDIF


;
; pascal SInt16 LMGetBufTgFBkNum(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetBufTgFBkNum     &dest=(sp)
            move.w            $0302,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetBufTgFBkNum
    ENDIF

;
; pascal void LMSetBufTgFBkNum(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetBufTgFBkNum     &src=(sp)+
            move.w            &src,$0302
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetBufTgFBkNum
    ENDIF


;
; pascal SInt32 LMGetBufTgDate(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetBufTgDate       &dest=(sp)
            move.l            $0304,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetBufTgDate
    ENDIF

;
; pascal void LMSetBufTgDate(SInt32 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetBufTgDate       &src=(sp)+
            move.l            &src,$0304
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetBufTgDate
    ENDIF


;
; pascal SInt32 LMGetLo3Bytes(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetLo3Bytes        &dest=(sp)
            move.l            $031A,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetLo3Bytes
    ENDIF

;
; pascal void LMSetLo3Bytes(SInt32 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetLo3Bytes        &src=(sp)+
            move.l            &src,$031A
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetLo3Bytes
    ENDIF


;
; pascal SInt32 LMGetMinStack(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetMinStack        &dest=(sp)
            move.l            $031E,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetMinStack
    ENDIF

;
; pascal void LMSetMinStack(SInt32 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetMinStack        &src=(sp)+
            move.l            &src,$031E
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetMinStack
    ENDIF


;
; pascal SInt32 LMGetDefltStack(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetDefltStack      &dest=(sp)
            move.l            $0322,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetDefltStack
    ENDIF

;
; pascal void LMSetDefltStack(SInt32 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetDefltStack      &src=(sp)+
            move.l            &src,$0322
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetDefltStack
    ENDIF


;
; pascal Handle LMGetGZRootHnd(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetGZRootHnd       &dest=(sp)
            move.l            $0328,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetGZRootHnd
    ENDIF

;
; pascal void LMSetGZRootHnd(Handle value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetGZRootHnd       &src=(sp)+
            move.l            &src,$0328
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetGZRootHnd
    ENDIF


;
; pascal Handle LMGetGZMoveHnd(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetGZMoveHnd       &dest=(sp)
            move.l            $0330,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetGZMoveHnd
    ENDIF

;
; pascal void LMSetGZMoveHnd(Handle value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetGZMoveHnd       &src=(sp)+
            move.l            &src,$0330
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetGZMoveHnd
    ENDIF


;
; pascal Ptr LMGetFCBSPtr(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetFCBSPtr         &dest=(sp)
            move.l            $034E,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetFCBSPtr
    ENDIF

;
; pascal void LMSetFCBSPtr(Ptr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetFCBSPtr         &src=(sp)+
            move.l            &src,$034E
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetFCBSPtr
    ENDIF


;
; pascal Ptr LMGetDefVCBPtr(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetDefVCBPtr       &dest=(sp)
            move.l            $0352,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetDefVCBPtr
    ENDIF

;
; pascal void LMSetDefVCBPtr(Ptr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetDefVCBPtr       &src=(sp)+
            move.l            &src,$0352
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetDefVCBPtr
    ENDIF


;
; pascal SInt32 LMGetCurDirStore(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetCurDirStore     &dest=(sp)
            move.l            $0398,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetCurDirStore
    ENDIF

;
; pascal void LMSetCurDirStore(SInt32 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetCurDirStore     &src=(sp)+
            move.l            &src,$0398
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetCurDirStore
    ENDIF


;
; pascal UniversalProcPtr LMGetToExtFS(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetToExtFS         &dest=(sp)
            move.l            $03F2,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetToExtFS
    ENDIF

;
; pascal void LMSetToExtFS(UniversalProcPtr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetToExtFS         &src=(sp)+
            move.l            &src,$03F2
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetToExtFS
    ENDIF


;
; pascal SInt16 LMGetFSFCBLen(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetFSFCBLen        &dest=(sp)
            move.w            $03F6,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetFSFCBLen
    ENDIF

;
; pascal void LMSetFSFCBLen(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetFSFCBLen        &src=(sp)+
            move.w            &src,$03F6
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetFSFCBLen
    ENDIF


;
; pascal Ptr LMGetScrnBase(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetScrnBase        &dest=(sp)
            move.l            $0824,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetScrnBase
    ENDIF

;
; pascal void LMSetScrnBase(Ptr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetScrnBase        &src=(sp)+
            move.l            &src,$0824
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetScrnBase
    ENDIF


;
; pascal GDHandle LMGetMainDevice(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetMainDevice      &dest=(sp)
            move.l            $08A4,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetMainDevice
    ENDIF

;
; pascal void LMSetMainDevice(GDHandle value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetMainDevice      &src=(sp)+
            move.l            &src,$08A4
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetMainDevice
    ENDIF


;
; pascal GDHandle LMGetDeviceList(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetDeviceList      &dest=(sp)
            move.l            $08A8,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetDeviceList
    ENDIF

;
; pascal void LMSetDeviceList(GDHandle value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetDeviceList      &src=(sp)+
            move.l            &src,$08A8
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetDeviceList
    ENDIF


;
; pascal Handle LMGetQDColors(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetQDColors        &dest=(sp)
            move.l            $08B0,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetQDColors
    ENDIF

;
; pascal void LMSetQDColors(Handle value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetQDColors        &src=(sp)+
            move.l            &src,$08B0
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetQDColors
    ENDIF


;
; pascal UInt8 LMGetCrsrBusy(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetCrsrBusy        &dest=(sp)
            move.b            $08CD,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetCrsrBusy
    ENDIF

;
; pascal void LMSetCrsrBusy(UInt8 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetCrsrBusy        &src=(sp)+
            move.b            &src,$08CD
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetCrsrBusy
    ENDIF


;
; pascal Handle LMGetWidthListHand(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetWidthListHand   &dest=(sp)
            move.l            $08E4,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetWidthListHand
    ENDIF

;
; pascal void LMSetWidthListHand(Handle value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetWidthListHand   &src=(sp)+
            move.l            &src,$08E4
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetWidthListHand
    ENDIF


;
; pascal SInt16 LMGetJournalRef(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetJournalRef      &dest=(sp)
            move.w            $08E8,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetJournalRef
    ENDIF

;
; pascal void LMSetJournalRef(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetJournalRef      &src=(sp)+
            move.w            &src,$08E8
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetJournalRef
    ENDIF


;
; pascal SInt16 LMGetCrsrThresh(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetCrsrThresh      &dest=(sp)
            move.w            $08EC,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetCrsrThresh
    ENDIF

;
; pascal void LMSetCrsrThresh(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetCrsrThresh      &src=(sp)+
            move.w            &src,$08EC
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetCrsrThresh
    ENDIF


;
; pascal UniversalProcPtr LMGetJFetch(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetJFetch          &dest=(sp)
            move.l            $08F4,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetJFetch
    ENDIF

;
; pascal void LMSetJFetch(UniversalProcPtr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetJFetch          &src=(sp)+
            move.l            &src,$08F4
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetJFetch
    ENDIF


;
; pascal UniversalProcPtr LMGetJStash(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetJStash          &dest=(sp)
            move.l            $08F8,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetJStash
    ENDIF

;
; pascal void LMSetJStash(UniversalProcPtr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetJStash          &src=(sp)+
            move.l            &src,$08F8
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetJStash
    ENDIF


;
; pascal UniversalProcPtr LMGetJIODone(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetJIODone         &dest=(sp)
            move.l            $08FC,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetJIODone
    ENDIF

;
; pascal void LMSetJIODone(UniversalProcPtr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetJIODone         &src=(sp)+
            move.l            &src,$08FC
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetJIODone
    ENDIF


;
; pascal SInt16 LMGetCurApRefNum(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetCurApRefNum     &dest=(sp)
            move.w            $0900,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetCurApRefNum
    ENDIF

;
; pascal void LMSetCurApRefNum(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetCurApRefNum     &src=(sp)+
            move.w            &src,$0900
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetCurApRefNum
    ENDIF


;
; pascal Ptr LMGetCurrentA5(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetCurrentA5       &dest=(sp)
            move.l            $0904,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetCurrentA5
    ENDIF

;
; pascal void LMSetCurrentA5(Ptr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetCurrentA5       &src=(sp)+
            move.l            &src,$0904
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetCurrentA5
    ENDIF


;
; pascal Ptr LMGetCurStackBase(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetCurStackBase    &dest=(sp)
            move.l            $0908,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetCurStackBase
    ENDIF

;
; pascal void LMSetCurStackBase(Ptr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetCurStackBase    &src=(sp)+
            move.l            &src,$0908
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetCurStackBase
    ENDIF


;
; pascal SInt16 LMGetCurJTOffset(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetCurJTOffset     &dest=(sp)
            move.w            $0934,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetCurJTOffset
    ENDIF

;
; pascal void LMSetCurJTOffset(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetCurJTOffset     &src=(sp)+
            move.w            &src,$0934
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetCurJTOffset
    ENDIF


;
; pascal SInt16 LMGetCurPageOption(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetCurPageOption   &dest=(sp)
            move.w            $0936,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetCurPageOption
    ENDIF

;
; pascal void LMSetCurPageOption(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetCurPageOption   &src=(sp)+
            move.w            &src,$0936
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetCurPageOption
    ENDIF


;
; pascal UInt8 LMGetHiliteMode(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetHiliteMode      &dest=(sp)
            move.b            $0938,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetHiliteMode
    ENDIF

;
; pascal void LMSetHiliteMode(UInt8 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetHiliteMode      &src=(sp)+
            move.b            &src,$0938
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetHiliteMode
    ENDIF


;
; pascal SInt16 LMGetPrintErr(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetPrintErr        &dest=(sp)
            move.w            $0944,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetPrintErr
    ENDIF

;
; pascal void LMSetPrintErr(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetPrintErr        &src=(sp)+
            move.w            &src,$0944
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetPrintErr
    ENDIF


;
; pascal SInt32 LMGetScrapSize(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetScrapSize       &dest=(sp)
            move.l            $0960,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetScrapSize
    ENDIF

;
; pascal void LMSetScrapSize(SInt32 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetScrapSize       &src=(sp)+
            move.l            &src,$0960
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetScrapSize
    ENDIF


;
; pascal Handle LMGetScrapHandle(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetScrapHandle     &dest=(sp)
            move.l            $0964,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetScrapHandle
    ENDIF

;
; pascal void LMSetScrapHandle(Handle value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetScrapHandle     &src=(sp)+
            move.l            &src,$0964
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetScrapHandle
    ENDIF


;
; pascal SInt16 LMGetScrapCount(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetScrapCount      &dest=(sp)
            move.w            $0968,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetScrapCount
    ENDIF

;
; pascal void LMSetScrapCount(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetScrapCount      &src=(sp)+
            move.w            &src,$0968
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetScrapCount
    ENDIF


;
; pascal SInt16 LMGetScrapState(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetScrapState      &dest=(sp)
            move.w            $096A,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetScrapState
    ENDIF

;
; pascal void LMSetScrapState(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetScrapState      &src=(sp)+
            move.w            &src,$096A
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetScrapState
    ENDIF


;
; pascal StringPtr LMGetScrapName(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetScrapName       &dest=(sp)
            move.l            $096C,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetScrapName
    ENDIF

;
; pascal void LMSetScrapName(StringPtr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetScrapName       &src=(sp)+
            move.l            &src,$096C
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetScrapName
    ENDIF


;
; pascal Handle LMGetROMFont0(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetROMFont0        &dest=(sp)
            move.l            $0980,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetROMFont0
    ENDIF

;
; pascal void LMSetROMFont0(Handle value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetROMFont0        &src=(sp)+
            move.l            &src,$0980
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetROMFont0
    ENDIF


;
; pascal SInt16 LMGetApFontID(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetApFontID        &dest=(sp)
            move.w            $0984,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetApFontID
    ENDIF

;
; pascal void LMSetApFontID(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetApFontID        &src=(sp)+
            move.w            &src,$0984
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetApFontID
    ENDIF



;
; pascal WindowPtr LMGetWindowList(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetWindowList      &dest=(sp)
            move.l            $09D6,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetWindowList
    ENDIF


;
; pascal SInt16 LMGetSaveUpdate(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSaveUpdate      &dest=(sp)
            move.w            $09DA,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSaveUpdate
    ENDIF

;
; pascal void LMSetSaveUpdate(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSaveUpdate      &src=(sp)+
            move.w            &src,$09DA
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSaveUpdate
    ENDIF


;
; pascal SInt16 LMGetPaintWhite(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetPaintWhite      &dest=(sp)
            move.w            $09DC,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetPaintWhite
    ENDIF

;
; pascal void LMSetPaintWhite(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetPaintWhite      &src=(sp)+
            move.w            &src,$09DC
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetPaintWhite
    ENDIF


;
; pascal GrafPtr LMGetWMgrPort(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetWMgrPort        &dest=(sp)
            move.l            $09DE,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetWMgrPort
    ENDIF

;
; pascal void LMSetWMgrPort(GrafPtr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetWMgrPort        &src=(sp)+
            move.l            &src,$09DE
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetWMgrPort
    ENDIF


;
; pascal RgnHandle LMGetGrayRgn(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetGrayRgn         &dest=(sp)
            move.l            $09EE,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetGrayRgn
    ENDIF


;
; pascal DragGrayRgnUPP LMGetDragHook(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetDragHook        &dest=(sp)
            move.l            $09F6,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetDragHook
    ENDIF

;
; pascal void LMSetDragHook(DragGrayRgnUPP value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetDragHook        &src=(sp)+
            move.l            &src,$09F6
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetDragHook
    ENDIF


;
; There is no reason to set the window list directly.
; Use BringToFront and SendBehind.
;
; If you need to do floating windows, avoid using GhostWindow
; and especially avoid patching the window manager.
;
; See Dean Yu's article in Develop 15 about how to implement floating
; windows using low-level window manager calls.  The next generation
; Macintosh Window Manager will have built-in support for floating
; and modal windows.
;

;
; pascal void LMSetWindowList(WindowPtr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetWindowList      &src=(sp)+
            move.l            &src,$09D6
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetWindowList
    ENDIF

;
; pascal WindowPtr LMGetGhostWindow(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetGhostWindow     &dest=(sp)
            move.l            $0A84,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetGhostWindow
    ENDIF

;
; pascal void LMSetGhostWindow(WindowPtr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetGhostWindow     &src=(sp)+
            move.l            &src,$0A84
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetGhostWindow
    ENDIF


;
; pascal AuxWinHandle LMGetAuxWinHead(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetAuxWinHead      &dest=(sp)
            move.l            $0CD0,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetAuxWinHead
    ENDIF

;
; pascal void LMSetAuxWinHead(AuxWinHandle value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetAuxWinHead      &src=(sp)+
            move.l            &src,$0CD0
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetAuxWinHead
    ENDIF

;
; pascal WindowPtr LMGetCurActivate(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetCurActivate     &dest=(sp)
            move.l            $0A64,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetCurActivate
    ENDIF

;
; pascal void LMSetCurActivate(WindowPtr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetCurActivate     &src=(sp)+
            move.l            &src,$0A64
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetCurActivate
    ENDIF

;
; pascal WindowPtr LMGetCurDeactive(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetCurDeactive     &dest=(sp)
            move.l            $0A68,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetCurDeactive
    ENDIF

;
; pascal void LMSetCurDeactive(WindowPtr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetCurDeactive     &src=(sp)+
            move.l            &src,$0A68
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetCurDeactive
    ENDIF


;
; pascal RgnHandle LMGetOldStructure(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetOldStructure    &dest=(sp)
            move.l            $09E6,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetOldStructure
    ENDIF

;
; pascal void LMSetOldStructure(RgnHandle value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetOldStructure    &src=(sp)+
            move.l            &src,$09E6
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetOldStructure
    ENDIF

;
; pascal RgnHandle LMGetOldContent(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetOldContent      &dest=(sp)
            move.l            $09EA,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetOldContent
    ENDIF

;
; pascal void LMSetOldContent(RgnHandle value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetOldContent      &src=(sp)+
            move.l            &src,$09EA
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetOldContent
    ENDIF


;
; Please don't mess with the gray region.  There has
; to be a better way.  If not, please manipulate the
; existing region, don't change the value of the lowmem.
;

;
; pascal void LMSetGrayRgn(RgnHandle value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetGrayRgn         &src=(sp)+
            move.l            &src,$09EE
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetGrayRgn
    ENDIF



;
; pascal RgnHandle LMGetSaveVisRgn(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSaveVisRgn      &dest=(sp)
            move.l            $09F2,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSaveVisRgn
    ENDIF

;
; pascal void LMSetSaveVisRgn(RgnHandle value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSaveVisRgn      &src=(sp)+
            move.l            &src,$09F2
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSaveVisRgn
    ENDIF




;
; pascal SInt32 LMGetOneOne(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetOneOne          &dest=(sp)
            move.l            $0A02,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetOneOne
    ENDIF

;
; pascal void LMSetOneOne(SInt32 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetOneOne          &src=(sp)+
            move.l            &src,$0A02
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetOneOne
    ENDIF


;
; pascal SInt32 LMGetMinusOne(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetMinusOne        &dest=(sp)
            move.l            $0A06,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetMinusOne
    ENDIF

;
; pascal void LMSetMinusOne(SInt32 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetMinusOne        &src=(sp)+
            move.l            &src,$0A06
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetMinusOne
    ENDIF


;
; pascal SInt16 LMGetTopMenuItem(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetTopMenuItem     &dest=(sp)
            move.w            $0A0A,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetTopMenuItem
    ENDIF

;
; pascal void LMSetTopMenuItem(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetTopMenuItem     &src=(sp)+
            move.w            &src,$0A0A
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetTopMenuItem
    ENDIF


;
; pascal SInt16 LMGetAtMenuBottom(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetAtMenuBottom    &dest=(sp)
            move.w            $0A0C,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetAtMenuBottom
    ENDIF

;
; pascal void LMSetAtMenuBottom(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetAtMenuBottom    &src=(sp)+
            move.w            &src,$0A0C
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetAtMenuBottom
    ENDIF


;
; pascal Handle LMGetMenuList(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetMenuList        &dest=(sp)
            move.l            $0A1C,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetMenuList
    ENDIF

;
; pascal void LMSetMenuList(Handle value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetMenuList        &src=(sp)+
            move.l            &src,$0A1C
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetMenuList
    ENDIF


;
; pascal SInt16 LMGetMBarEnable(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetMBarEnable      &dest=(sp)
            move.w            $0A20,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetMBarEnable
    ENDIF

;
; pascal void LMSetMBarEnable(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetMBarEnable      &src=(sp)+
            move.w            &src,$0A20
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetMBarEnable
    ENDIF


;
; pascal SInt16 LMGetMenuFlash(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetMenuFlash       &dest=(sp)
            move.w            $0A24,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetMenuFlash
    ENDIF

;
; pascal void LMSetMenuFlash(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetMenuFlash       &src=(sp)+
            move.w            &src,$0A24
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetMenuFlash
    ENDIF


;
; pascal SInt16 LMGetTheMenu(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetTheMenu         &dest=(sp)
            move.w            $0A26,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetTheMenu
    ENDIF

;
; pascal void LMSetTheMenu(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetTheMenu         &src=(sp)+
            move.w            &src,$0A26
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetTheMenu
    ENDIF


;
; pascal MBarHookUPP LMGetMBarHook(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetMBarHook        &dest=(sp)
            move.l            $0A2C,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetMBarHook
    ENDIF

;
; pascal void LMSetMBarHook(MBarHookUPP value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetMBarHook        &src=(sp)+
            move.l            &src,$0A2C
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetMBarHook
    ENDIF


;
; pascal MenuHookUPP LMGetMenuHook(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetMenuHook        &dest=(sp)
            move.l            $0A30,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetMenuHook
    ENDIF

;
; pascal void LMSetMenuHook(MenuHookUPP value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetMenuHook        &src=(sp)+
            move.l            &src,$0A30
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetMenuHook
    ENDIF


;
; pascal Handle LMGetTopMapHndl(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetTopMapHndl      &dest=(sp)
            move.l            $0A50,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetTopMapHndl
    ENDIF

;
; pascal void LMSetTopMapHndl(Handle value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetTopMapHndl      &src=(sp)+
            move.l            &src,$0A50
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetTopMapHndl
    ENDIF


;
; pascal Handle LMGetSysMapHndl(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSysMapHndl      &dest=(sp)
            move.l            $0A54,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSysMapHndl
    ENDIF

;
; pascal void LMSetSysMapHndl(Handle value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSysMapHndl      &src=(sp)+
            move.l            &src,$0A54
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSysMapHndl
    ENDIF


;
; pascal SInt16 LMGetSysMap(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSysMap          &dest=(sp)
            move.w            $0A58,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSysMap
    ENDIF

;
; pascal void LMSetSysMap(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSysMap          &src=(sp)+
            move.w            &src,$0A58
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSysMap
    ENDIF


;
; pascal SInt16 LMGetCurMap(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetCurMap          &dest=(sp)
            move.w            $0A5A,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetCurMap
    ENDIF

;
; pascal void LMSetCurMap(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetCurMap          &src=(sp)+
            move.w            &src,$0A5A
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetCurMap
    ENDIF


;
; pascal UInt8 LMGetResLoad(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetResLoad         &dest=(sp)
            move.b            $0A5E,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetResLoad
    ENDIF

;
; pascal void LMSetResLoad(UInt8 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetResLoad         &src=(sp)+
            move.b            &src,$0A5E
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetResLoad
    ENDIF


;
; pascal SInt16 LMGetResErr(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetResErr          &dest=(sp)
            move.w            $0A60,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetResErr
    ENDIF

;
; pascal void LMSetResErr(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetResErr          &src=(sp)+
            move.w            &src,$0A60
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetResErr
    ENDIF


;
; pascal UInt8 LMGetFScaleDisable(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetFScaleDisable   &dest=(sp)
            move.b            $0A63,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetFScaleDisable
    ENDIF

;
; pascal void LMSetFScaleDisable(UInt8 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetFScaleDisable   &src=(sp)+
            move.b            &src,$0A63
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetFScaleDisable
    ENDIF


;
; pascal UniversalProcPtr LMGetDeskHook(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetDeskHook        &dest=(sp)
            move.l            $0A6C,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetDeskHook
    ENDIF

;
; pascal void LMSetDeskHook(UniversalProcPtr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetDeskHook        &src=(sp)+
            move.l            &src,$0A6C
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetDeskHook
    ENDIF


;
; pascal UniversalProcPtr LMGetTEDoText(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetTEDoText        &dest=(sp)
            move.l            $0A70,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetTEDoText
    ENDIF

;
; pascal void LMSetTEDoText(UniversalProcPtr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetTEDoText        &src=(sp)+
            move.l            &src,$0A70
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetTEDoText
    ENDIF


;
; pascal UniversalProcPtr LMGetTERecal(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetTERecal         &dest=(sp)
            move.l            $0A74,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetTERecal
    ENDIF

;
; pascal void LMSetTERecal(UniversalProcPtr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetTERecal         &src=(sp)+
            move.l            &src,$0A74
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetTERecal
    ENDIF


;
; pascal UniversalProcPtr LMGetResumeProc(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetResumeProc      &dest=(sp)
            move.l            $0A8C,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetResumeProc
    ENDIF

;
; pascal void LMSetResumeProc(UniversalProcPtr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetResumeProc      &src=(sp)+
            move.l            &src,$0A8C
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetResumeProc
    ENDIF


;
; pascal SInt16 LMGetANumber(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetANumber         &dest=(sp)
            move.w            $0A98,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetANumber
    ENDIF

;
; pascal void LMSetANumber(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetANumber         &src=(sp)+
            move.w            &src,$0A98
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetANumber
    ENDIF


;
; pascal SInt16 LMGetACount(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetACount          &dest=(sp)
            move.w            $0A9A,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetACount
    ENDIF

;
; pascal void LMSetACount(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetACount          &src=(sp)+
            move.w            &src,$0A9A
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetACount
    ENDIF


;
; pascal UniversalProcPtr LMGetDABeeper(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetDABeeper        &dest=(sp)
            move.l            $0A9C,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetDABeeper
    ENDIF

;
; pascal void LMSetDABeeper(UniversalProcPtr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetDABeeper        &src=(sp)+
            move.l            &src,$0A9C
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetDABeeper
    ENDIF


;
; pascal UInt16 LMGetTEScrpLength(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetTEScrpLength    &dest=(sp)
            move.w            $0AB0,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetTEScrpLength
    ENDIF

;
; pascal void LMSetTEScrpLength(UInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetTEScrpLength    &src=(sp)+
            move.w            &src,$0AB0
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetTEScrpLength
    ENDIF


;
; pascal Handle LMGetTEScrpHandle(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetTEScrpHandle    &dest=(sp)
            move.l            $0AB4,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetTEScrpHandle
    ENDIF

;
; pascal void LMSetTEScrpHandle(Handle value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetTEScrpHandle    &src=(sp)+
            move.l            &src,$0AB4
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetTEScrpHandle
    ENDIF


;
; pascal Handle LMGetAppParmHandle(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetAppParmHandle   &dest=(sp)
            move.l            $0AEC,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetAppParmHandle
    ENDIF

;
; pascal void LMSetAppParmHandle(Handle value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetAppParmHandle   &src=(sp)+
            move.l            &src,$0AEC
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetAppParmHandle
    ENDIF


;
; pascal SInt16 LMGetDSErrCode(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetDSErrCode       &dest=(sp)
            move.w            $0AF0,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetDSErrCode
    ENDIF

;
; pascal void LMSetDSErrCode(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetDSErrCode       &src=(sp)+
            move.w            &src,$0AF0
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetDSErrCode
    ENDIF


;
; pascal ResErrUPP LMGetResErrProc(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetResErrProc      &dest=(sp)
            move.l            $0AF2,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetResErrProc
    ENDIF

;
; pascal void LMSetResErrProc(ResErrUPP value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetResErrProc      &src=(sp)+
            move.l            &src,$0AF2
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetResErrProc
    ENDIF


;
; pascal SInt16 LMGetDlgFont(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetDlgFont         &dest=(sp)
            move.w            $0AFA,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetDlgFont
    ENDIF

;
; pascal void LMSetDlgFont(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetDlgFont         &src=(sp)+
            move.w            &src,$0AFA
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetDlgFont
    ENDIF


;
; pascal Ptr LMGetWidthPtr(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetWidthPtr        &dest=(sp)
            move.l            $0B10,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetWidthPtr
    ENDIF

;
; pascal void LMSetWidthPtr(Ptr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetWidthPtr        &src=(sp)+
            move.l            &src,$0B10
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetWidthPtr
    ENDIF


;
; pascal Ptr LMGetATalkHk2(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetATalkHk2        &dest=(sp)
            move.l            $0B18,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetATalkHk2
    ENDIF

;
; pascal void LMSetATalkHk2(Ptr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetATalkHk2        &src=(sp)+
            move.l            &src,$0B18
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetATalkHk2
    ENDIF


;
; pascal SInt16 LMGetHWCfgFlags(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetHWCfgFlags      &dest=(sp)
            move.w            $0B22,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetHWCfgFlags
    ENDIF

;
; pascal void LMSetHWCfgFlags(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetHWCfgFlags      &src=(sp)+
            move.w            &src,$0B22
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetHWCfgFlags
    ENDIF


;
; pascal Handle LMGetWidthTabHandle(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetWidthTabHandle  &dest=(sp)
            move.l            $0B2A,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetWidthTabHandle
    ENDIF

;
; pascal void LMSetWidthTabHandle(Handle value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetWidthTabHandle  &src=(sp)+
            move.l            &src,$0B2A
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetWidthTabHandle
    ENDIF


;
; pascal SInt32 LMGetLastSPExtra(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetLastSPExtra     &dest=(sp)
            move.l            $0B4C,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetLastSPExtra
    ENDIF

;
; pascal void LMSetLastSPExtra(SInt32 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetLastSPExtra     &src=(sp)+
            move.l            &src,$0B4C
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetLastSPExtra
    ENDIF


;
; pascal SInt32 LMGetMenuDisable(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetMenuDisable     &dest=(sp)
            move.l            $0B54,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetMenuDisable
    ENDIF

;
; pascal void LMSetMenuDisable(SInt32 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetMenuDisable     &src=(sp)+
            move.l            &src,$0B54
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetMenuDisable
    ENDIF


;
; pascal UInt8 LMGetROMMapInsert(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetROMMapInsert    &dest=(sp)
            move.b            $0B9E,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetROMMapInsert
    ENDIF

;
; pascal void LMSetROMMapInsert(UInt8 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetROMMapInsert    &src=(sp)+
            move.b            &src,$0B9E
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetROMMapInsert
    ENDIF


;
; pascal UInt8 LMGetTmpResLoad(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetTmpResLoad      &dest=(sp)
            move.b            $0B9F,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetTmpResLoad
    ENDIF

;
; pascal void LMSetTmpResLoad(UInt8 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetTmpResLoad      &src=(sp)+
            move.b            &src,$0B9F
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetTmpResLoad
    ENDIF


;
; pascal Ptr LMGetIntlSpec(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetIntlSpec        &dest=(sp)
            move.l            $0BA0,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetIntlSpec
    ENDIF

;
; pascal void LMSetIntlSpec(Ptr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetIntlSpec        &src=(sp)+
            move.l            &src,$0BA0
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetIntlSpec
    ENDIF


;
; pascal UInt8 LMGetWordRedraw(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetWordRedraw      &dest=(sp)
            move.b            $0BA5,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetWordRedraw
    ENDIF

;
; pascal void LMSetWordRedraw(UInt8 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetWordRedraw      &src=(sp)+
            move.b            &src,$0BA5
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetWordRedraw
    ENDIF


;
; pascal SInt16 LMGetSysFontFam(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSysFontFam      &dest=(sp)
            move.w            $0BA6,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSysFontFam
    ENDIF

;
; pascal void LMSetSysFontFam(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSysFontFam      &src=(sp)+
            move.w            &src,$0BA6
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSysFontFam
    ENDIF


;
; pascal SInt16 LMGetSysFontSize(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSysFontSize     &dest=(sp)
            move.w            $0BA8,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSysFontSize
    ENDIF

;
; pascal void LMSetSysFontSize(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSysFontSize     &src=(sp)+
            move.w            &src,$0BA8
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSysFontSize
    ENDIF


;
; pascal SInt16 LMGetMBarHeight(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetMBarHeight      &dest=(sp)
            move.w            $0BAA,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetMBarHeight
    ENDIF

;
; pascal void LMSetMBarHeight(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetMBarHeight      &src=(sp)+
            move.w            &src,$0BAA
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetMBarHeight
    ENDIF


;
; pascal SInt16 LMGetTESysJust(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetTESysJust       &dest=(sp)
            move.w            $0BAC,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetTESysJust
    ENDIF

;
; pascal void LMSetTESysJust(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetTESysJust       &src=(sp)+
            move.w            &src,$0BAC
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetTESysJust
    ENDIF


;
; pascal Handle LMGetLastFOND(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetLastFOND        &dest=(sp)
            move.l            $0BC2,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetLastFOND
    ENDIF

;
; pascal void LMSetLastFOND(Handle value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetLastFOND        &src=(sp)+
            move.l            &src,$0BC2
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetLastFOND
    ENDIF


;
; pascal UInt8 LMGetFractEnable(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetFractEnable     &dest=(sp)
            move.b            $0BF4,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetFractEnable
    ENDIF

;
; pascal void LMSetFractEnable(UInt8 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetFractEnable     &src=(sp)+
            move.b            &src,$0BF4
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetFractEnable
    ENDIF


;
; pascal UInt8 LMGetMMU32Bit(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetMMU32Bit        &dest=(sp)
            move.b            $0CB2,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetMMU32Bit
    ENDIF

;
; pascal void LMSetMMU32Bit(UInt8 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetMMU32Bit        &src=(sp)+
            move.b            &src,$0CB2
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetMMU32Bit
    ENDIF


;
; pascal GDHandle LMGetTheGDevice(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetTheGDevice      &dest=(sp)
            move.l            $0CC8,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetTheGDevice
    ENDIF

;
; pascal void LMSetTheGDevice(GDHandle value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetTheGDevice      &src=(sp)+
            move.l            &src,$0CC8
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetTheGDevice
    ENDIF


;
; pascal PixPatHandle LMGetDeskCPat(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetDeskCPat        &dest=(sp)
            move.l            $0CD8,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetDeskCPat
    ENDIF

;
; pascal void LMSetDeskCPat(PixPatHandle value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetDeskCPat        &src=(sp)+
            move.l            &src,$0CD8
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetDeskCPat
    ENDIF


;
; pascal SInt16 LMGetTimeDBRA(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetTimeDBRA        &dest=(sp)
            move.w            $0D00,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetTimeDBRA
    ENDIF

;
; pascal void LMSetTimeDBRA(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetTimeDBRA        &src=(sp)+
            move.w            &src,$0D00
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetTimeDBRA
    ENDIF


;
; pascal SInt16 LMGetTimeSCCDB(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetTimeSCCDB       &dest=(sp)
            move.w            $0D02,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetTimeSCCDB
    ENDIF

;
; pascal void LMSetTimeSCCDB(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetTimeSCCDB       &src=(sp)+
            move.w            &src,$0D02
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetTimeSCCDB
    ENDIF


;
; pascal UniversalProcPtr LMGetJVBLTask(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetJVBLTask        &dest=(sp)
            move.l            $0D28,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetJVBLTask
    ENDIF

;
; pascal void LMSetJVBLTask(UniversalProcPtr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetJVBLTask        &src=(sp)+
            move.l            &src,$0D28
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetJVBLTask
    ENDIF


;
; pascal Handle LMGetSynListHandle(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetSynListHandle   &dest=(sp)
            move.l            $0D32,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSynListHandle
    ENDIF

;
; pascal void LMSetSynListHandle(Handle value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetSynListHandle   &src=(sp)+
            move.l            &src,$0D32
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSynListHandle
    ENDIF


;
; pascal MCTableHandle LMGetMenuCInfo(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetMenuCInfo       &dest=(sp)
            move.l            $0D50,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetMenuCInfo
    ENDIF

;
; pascal void LMSetMenuCInfo(MCTableHandle value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetMenuCInfo       &src=(sp)+
            move.l            &src,$0D50
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetMenuCInfo
    ENDIF


;
; pascal UniversalProcPtr LMGetJDTInstall(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetJDTInstall      &dest=(sp)
            move.l            $0D9C,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetJDTInstall
    ENDIF

;
; pascal void LMSetJDTInstall(UniversalProcPtr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetJDTInstall      &src=(sp)+
            move.l            &src,$0D9C
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetJDTInstall
    ENDIF


;
; pascal SInt16 LMGetTimeSCSIDB(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetTimeSCSIDB      &dest=(sp)
            move.w            $0B24,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetTimeSCSIDB
    ENDIF

;
; pascal void LMSetTimeSCSIDB(SInt16 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetTimeSCSIDB      &src=(sp)+
            move.w            &src,$0B24
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetTimeSCSIDB
    ENDIF



; **************************************************************************************
;
;    MORE COMPLEX LOWMEM ACCESSORS
;
;*************************************************************************************

    IF TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
; **************************************************************************************
;    "BIG DATA"
;
;        These lowmem accessors access big (> 4 bytes) values.
;*************************************************************************************

; **************************************************************************************
;    "BLOCKMOVE ACCESSORS"
;
;        These lowmem accessors use the BlockMove to set
;*************************************************************************************

; **************************************************************************************
;    "INDEXED ACCESSORS"
;
;        These lowmem accessors take an index parameter to get/set an indexed
;        lowmem global.
;*************************************************************************************

    ELSE
; **************************************************************************************
;    "BIG DATA"
;
;        These lowmem accessors access big (> 4 bytes) values.
;*************************************************************************************

;
; pascal void LMGetDSAlertRect(Rect *dsAlertRectValue)
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetDSAlertRect
    ENDIF

;
; pascal void LMSetDSAlertRect(const Rect *dsAlertRectValue)
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetDSAlertRect
    ENDIF

;
; pascal void LMGetDragPattern(Pattern *dragPatternValue)
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetDragPattern
    ENDIF

;
; pascal void LMSetDragPattern(const Pattern *dragPatternValue)
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetDragPattern
    ENDIF

;
; pascal void LMGetDeskPattern(Pattern *deskPatternValue)
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetDeskPattern
    ENDIF

;
; pascal void LMSetDeskPattern(const Pattern *deskPatternValue)
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetDeskPattern
    ENDIF

;
; pascal void LMGetHiliteRGB(RGBColor *hiliteRGBValue)
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetHiliteRGB
    ENDIF

;
; pascal void LMSetHiliteRGB(const RGBColor *hiliteRGBValue)
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetHiliteRGB
    ENDIF

;
; pascal QHdrPtr LMGetEventQueue(void )
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetEventQueue
    ENDIF

;
; pascal void LMSetEventQueue(QHdrPtr eventQueueValue)
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetEventQueue
    ENDIF

;
; pascal QHdrPtr LMGetVBLQueue(void )
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetVBLQueue
    ENDIF

;
; pascal void LMSetVBLQueue(QHdrPtr vblQueueValue)
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetVBLQueue
    ENDIF

;
; pascal QHdrPtr LMGetDrvQHdr(void )
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetDrvQHdr
    ENDIF

;
; pascal void LMSetDrvQHdr(QHdrPtr drvQHdrValue)
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetDrvQHdr
    ENDIF

;
; pascal QHdrPtr LMGetVCBQHdr(void )
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetVCBQHdr
    ENDIF

;
; pascal void LMSetVCBQHdr(QHdrPtr vcbQHdrValue)
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetVCBQHdr
    ENDIF

;
; pascal QHdrPtr LMGetDTQueue(void )
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetDTQueue
    ENDIF

;
; pascal void LMSetDTQueue(QHdrPtr dtQueueValue)
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetDTQueue
    ENDIF

;
; pascal QHdrPtr LMGetFSQHdr(void )
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetFSQHdr
    ENDIF

; **************************************************************************************
;    "BLOCKMOVE ACCESSORS"
;
;        These lowmem accessors use the BlockMove to set
;*************************************************************************************

;
; pascal StringPtr LMGetCurApName(void )
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetCurApName
    ENDIF

;
; pascal void LMSetCurApName(ConstStr31Param curApNameValue)
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetCurApName
    ENDIF

;
; pascal StringPtr LMGetSysResName(void )
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetSysResName
    ENDIF

;
; pascal void LMSetSysResName(ConstStr15Param sysResNameValue)
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetSysResName
    ENDIF

;
; pascal StringPtr LMGetFinderName(void )
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetFinderName
    ENDIF

;
; pascal void LMSetFinderName(ConstStr15Param finderNameValue)
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetFinderName
    ENDIF

;
; pascal Ptr LMGetScratch20(void )
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetScratch20
    ENDIF

;
; pascal void LMSetScratch20(const void *scratch20Value)
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetScratch20
    ENDIF

;
; pascal Ptr LMGetToolScratch(void )
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetToolScratch
    ENDIF

;
; pascal void LMSetToolScratch(const void *toolScratchValue)
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetToolScratch
    ENDIF

;
; pascal Ptr LMGetApplScratch(void )
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetApplScratch
    ENDIF

;
; pascal void LMSetApplScratch(const void *applScratchValue)
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetApplScratch
    ENDIF


; **************************************************************************************
;    "INDEXED ACCESSORS"
;
;        These lowmem accessors take an index parameter to get/set an indexed
;        lowmem global.
;*************************************************************************************

;
; pascal StringHandle LMGetDAStrings(short whichString)
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetDAStrings
    ENDIF

;
; pascal void LMSetDAStrings(StringHandle stringsValue, short whichString)
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetDAStrings
    ENDIF

;
; pascal UniversalProcPtr LMGetLvl2DT(short vectorNumber)
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetLvl2DT
    ENDIF

;
; pascal void LMSetLvl2DT(UniversalProcPtr Lvl2DTValue, short vectorNumber)
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetLvl2DT
    ENDIF

;
; pascal UniversalProcPtr LMGetExtStsDT(short vectorNumber)
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetExtStsDT
    ENDIF

;
; pascal void LMSetExtStsDT(UniversalProcPtr ExtStsDTValue, short vectorNumber)
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetExtStsDT
    ENDIF

    ENDIF
; **************************************************************************************
;    "Missing Accessors"
;
;        These lowmem accessors are not in InterfaceLib and were missing from
;        previous versions of LowMem.h.  Because they are not in InterfaceLib,
;        C macros were added to directly inline the accessors.
;
;*************************************************************************************

;  accesses "CrsrNew"
;
; pascal Boolean LMGetCursorNew(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetCursorNew       &dest=(sp)
            move.b            $08CE,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetCursorNew
    ENDIF

;
; pascal void LMSetCursorNew(Boolean value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetCursorNew       &src=(sp)+
            move.b            &src,$08CE
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetCursorNew
    ENDIF


;  accesses "MBState"
;
; pascal UInt8 LMGetMouseButtonState(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetMouseButtonState &dest=(sp)
            move.b            $0172,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetMouseButtonState
    ENDIF

;
; pascal void LMSetMouseButtonState(UInt8 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetMouseButtonState &src=(sp)+
            move.b            &src,$0172
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetMouseButtonState
    ENDIF


;  accesses "MTemp"
;
; pascal Point LMGetMouseTemp(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetMouseTemp       &dest=(sp)
            move.l            $0828,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetMouseTemp
    ENDIF

;
; pascal void LMSetMouseTemp(Point value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetMouseTemp       &src=(sp)+
            move.l            &src,$0828
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetMouseTemp
    ENDIF


;  accesses "RawMouse"
;
; pascal Point LMGetRawMouseLocation(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetRawMouseLocation &dest=(sp)
            move.l            $082C,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetRawMouseLocation
    ENDIF

;
; pascal void LMSetRawMouseLocation(Point value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetRawMouseLocation &src=(sp)+
            move.l            &src,$082C
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetRawMouseLocation
    ENDIF


;  accesses "Mouse"
;
; pascal Point LMGetMouseLocation(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetMouseLocation   &dest=(sp)
            move.l            $0830,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetMouseLocation
    ENDIF

;
; pascal void LMSetMouseLocation(Point value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetMouseLocation   &src=(sp)+
            move.l            &src,$0830
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetMouseLocation
    ENDIF


;  accesses "TheCrsr"
;
; extern void LMGetTheCursor(Cursor *currentCursor)
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetTheCursor
    ENDIF

;
; extern void LMSetTheCursor(const Cursor *newCursor)
;
    IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetTheCursor
    ENDIF

;  accesses "HiHeapMark"
;
; pascal Ptr LMGetHighHeapMark(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetHighHeapMark    &dest=(sp)
            move.l            $0BAE,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetHighHeapMark
    ENDIF

;
; pascal void LMSetHighHeapMark(Ptr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetHighHeapMark    &src=(sp)+
            move.l            &src,$0BAE
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetHighHeapMark
    ENDIF


;  accesses "StkLowPt"
;
; pascal Ptr LMGetStackLowPoint(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetStackLowPoint   &dest=(sp)
            move.l            $0110,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetStackLowPoint
    ENDIF

;
; pascal void LMSetStackLowPoint(Ptr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetStackLowPoint   &src=(sp)+
            move.l            &src,$0110
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetStackLowPoint
    ENDIF


;  accesses "ROMMapHndl"
;
; pascal Handle LMGetROMMapHandle(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetROMMapHandle    &dest=(sp)
            move.l            $0B06,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetROMMapHandle
    ENDIF

;
; pascal void LMSetROMMapHandle(Handle value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetROMMapHandle    &src=(sp)+
            move.l            &src,$0B06
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetROMMapHandle
    ENDIF


;  accesses "UnitNtryCnt"
;
; pascal short LMGetUnitTableEntryCount(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetUnitTableEntryCount &dest=(sp)
            move.w            $01D2,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetUnitTableEntryCount
    ENDIF

;
; pascal void LMSetUnitTableEntryCount(short value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetUnitTableEntryCount &src=(sp)+
            move.w            &src,$01D2
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetUnitTableEntryCount
    ENDIF


;  accesses "FmtDefaults"
;
; pascal Ptr LMGetDiskFormatingHFSDefaults(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetDiskFormatingHFSDefaults &dest=(sp)
            move.l            $039E,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetDiskFormatingHFSDefaults
    ENDIF

;
; pascal void LMSetDiskFormatingHFSDefaults(Ptr value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetDiskFormatingHFSDefaults &src=(sp)+
            move.l            &src,$039E
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetDiskFormatingHFSDefaults
    ENDIF


;  accesses "PortAUse"
;
; pascal UInt8 LMGetPortAInfo(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetPortAInfo       &dest=(sp)
            move.b            $0290,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetPortAInfo
    ENDIF

;
; pascal void LMSetPortAInfo(UInt8 value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetPortAInfo       &src=(sp)+
            move.b            &src,$0290
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetPortAInfo
    ENDIF



;  These are in InterfaceLib as of Allegro

;
; pascal long LMGetMBTicks(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetMBTicks         &dest=(sp)
            move.l            $016E,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetMBTicks
    ENDIF

;
; pascal void LMSetMBTicks(long value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetMBTicks         &src=(sp)+
            move.l            &src,$016E
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetMBTicks
    ENDIF


;
; pascal long LMGetKeyTime(void)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMGetKeyTime         &dest=(sp)
            move.l            $0186,&dest
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMGetKeyTime
    ENDIF

;
; pascal void LMSetKeyTime(long value)
;
    IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
        Macro
        _LMSetKeyTime         &src=(sp)+
            move.l            &src,$0186
        EndM
    ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
        IMPORT_CFM_FUNCTION LMSetKeyTime
    ENDIF



    ENDIF ; __LOWMEM__